# 作业：
# 一、定义一个学生Student类。有下面的类属性：
# 1 姓名 name
# 2 年龄 age
# 3 成绩 score（语文，数学，英语) [每课成绩的类型为整数]
# 类方法：
#  1 获取学生的姓名：get_name() 返回类型:str
# 2 获取学生的年龄：get_age() 返回类型:int
# 3 返回3门科目中最高的分数。get_course() 返回类型:int
# 4 将每个实例学生对象写进txt文件里，要持久保存
# 举例：{"姓名":"a","年龄":29,"成绩":{"语文":99,"数学":100,"英语":85}
# 5 获取所有学生的信息
# 写好类以后，可以定义2个同学测试下:
# zm = Student('zhangming',20,[69,88,100])
"""class Student: #定义一个学生Student类
    def __init__(self,name,age,score): #初始化
        self.name = name #属性
        self.age = age
        self.score = score
        #self.chinese_score=chinese_score
        # self.math_score = math_score
        # self.english_score = english_score
        with open("student.txt", 'a', encoding='utf-8') as f: #将每个实例学生对象写进txt文件里，要持久保存 'a'续写累加
            f.write(f"姓名:{self.name} 年龄:{self.age} 成绩：{{语文:{score[0]} 数学:{score[1]} 英语:{score[2]}}}\n") #}}一个是字典一个执行
    def course(self):
        print('course')
    def get_name(self): #定义名字函数
        return self.name
    def get_age(self): #定义年龄函数
        return self.age
    def get_course(self): #定义最高分数函数
        with open("student.txt", 'r', encoding='utf-8') as f:  #打开txt文件并读取
            print(f.read())
zm = Student('zhangming',20,[69,88,100])
zm.get_course()
"""
"""class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def print_score(self):
        with open("student.txt", 'a', encoding='utf-8') as f:
            f.write(f"姓名:{self.name} 年龄:{self.age} 成绩：{{语文:{self.score[0]} 数学:{self.score[1]} 英语:{self.score[2]}}}\n")
            for i in range(len(self.score)):
                if self.score[i] == max(self.score):
                    print(f"{i + 1}科成绩最高")
                else:
                    print(f"{i + 1}科成绩最低")

            if self.score[0] > self.score[1]:
                print("语文成绩最高")
            else:
                print("数学成绩最高")
            if self.score[0] > self.score[2]:
                print("语文成绩最高")
            else:
                print("英语成绩最高")
            if self.score[1] > self.score[2]:
                print("数学成绩最高")
            else:
                print("英语成绩最高")"""
# 二、定义一个字典类：dictclass。完成下面的功能：
# 1 删除某个key
# 2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
# 3 返回键组成的列表：返回类型;(list)
# 4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
"""class My_dict:  
    def __init__(self, data):  
        self.data = data  
# 1 删除某个key
# 2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
    def del_key(self, key):  
        if key in self.data:  
            del self.data[key]  
        else:  
            print("not found!")  

    def is_key(self, key):  
        if key in self.data:  
            print("键'%s'在字典中" % key)  
        else:  
            print("not found!")  
# 3 返回键组成的列表：返回类型;(list)  
    def get_key(self):  
        return list(self.data.keys()) 
# 4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)          
    def update_dict(self, dict1):  
        self.data = {**self.data, **dict1}  
        return list(self.data.values())  
  
dict_data = {"a": 1, "b": 2, "c": 3}  
d = My_dict(dict_data)  
print(d.data)  
d.is_key("a")  
d.del_key("a")  
print(d.data)  
d.is_key("a")  
print(d.get_key())
"""
# 四、定义一个列表的操作类：Listinfo
# 包括的方法:
# 1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
# 2 列表元素取值：get_key(num) [num:整数类型]
# 3 列表合并：update_list(list) [list:列表类型]
# 4 删除并且返回最后一个元素：del_key()
"""
class Listinfo:
    def __init__(self):
        self.data = {}
# 1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
    def add_key(self, keyname):
        if type(keyname) == str or type(keyname) == int:
            self.data[keyname] = []
        else:
            print("添加的元素的类型错误")
# 2 列表元素取值：get_key(num) [num:整数类型]
    def get_key(self, key):
        if key in self.data:
            return self.data[key]
        else:
            print("键不存在")
# 3 列表合并：update_list(list) [list:列表类型]
    def update_list(self, key, list_values):
        if list_values:
            self.data[key] += list_values
# 4 删除并且返回最后一个元素：del_key()
    def remove_last_key_value_pair(self):
    if self.list1:
        length = len(self.list1)
        if length > 0:
            key = self.list1[length-1][0]
            value = self.list1[length-1][1]
            del self.list1[length-1]
            return (key, value)
        else:
            return None


my_list = Listinfo()
other_list = ["banana", "orange"]
my_list.add_key("fruit")
print(my_list.get_key("fruit"))
my_list.update_list("fruit", ["apple", "pear"])
print(my_list.get_key("fruit"))
print(my_list.remove_last_key_value_pair("fruit"))
print(my_list.get_key("fruit"))
  """

#  五、做一个学生点名系统，系统里支持：存入学生、更改学生、删除学生、点到学生姓名方法
# 存入学生（姓名、年龄、家庭地址、手机号）： 存入成功后，提示xxx存入成功
# 更改学生（姓名、年龄、家庭地址、手机号）：可以修改学生内容的任意一个字段
# 删除学生：删除的学生将不在展示
# 展示全部学生：可以看到全部的学生姓名
# 学生姓名：随机抽取任意一个存在的学生信息，然后打印：到！。举例： 刘闯到！
"""
import random
class StudentSystem:
    def __init__(self):
        self.students = {}
# 存入学生（姓名、年龄、家庭地址、手机号）      
    def save_student(self, name, age, address, phone):
        self.students[name] = {"age": age, "address": address, "phone": phone}
        print(f"{name}存入成功！")
# 更改学生（姓名、年龄、家庭地址、手机号）     
    def change_student(self, name, field, value):
        if name in self.students:
            if field in self.students[name]:
                self.students[name][field] = value
                print(f"成功修改{name}的{field}！")
            else:
                print(f"{field}在{name}的信息中不存在！")
        else:
            print(f"{name}不存在！")
# 删除学生：删除的学生将不在展示            
    def delete_student(self, name):
        if name in self.students:
            del self.students[name]
            print(f"{name}已删除！")
        else:
            print(f"{name}不存在！")
# 展示全部学生：可以看到全部的学生姓名            
    def show_all_students(self):
        for name, details in self.students.items():
            print(f"{name}：年龄{details['age']}，地址{details['address']}，手机号{details['phone']}") #detail{}详细值
# 学生姓名：随机抽取任意一个存在的学生信息，然后打印：到！。举例： 刘闯到！
    def call_roll(self):
        if self.students:
            student_name = random.choice(list(self.students.keys()))
            print(f"{student_name}到！")
        else:
            print("还没有学生信息！")

system = StudentSystem()
system.save_student("xrh", 8, "北京市", "13000000000")
system.save_student("liyang", 22, "上海市", "13100000000")
system.call_roll()  
system.change_student("xrh", "age", 21)  
system.show_all_students()  
system.delete_student("liyang")  
system.show_all_students()  
"""
# 六、点餐管理系统
# 1》、餐馆可以新增菜品、下架菜品、修改菜品
# 2》、每个菜品，都有对应的库存，所有菜品的库存均为999，每出一道菜，库存-1
# 菜品有对应的价格，餐厅老板定义价格每道菜不允许超过15元，没有小数单位，均为整数
# 3》、餐馆后台有点赞系统，能够收集客户对菜品的喜好，0~5分
# 4》、有菜品评分提报功能，对平均分数（菜品总分/打分人数）低于3分的菜品进行强制下架；
"""class Restaurant:  
    def __init__(self):  
        self.dishes = []  
        self.scores = {}  
     
# 新增菜品
    def add_dish(self, name, price):  
        dish = {"name": name, "price": price, "stock": 999}  
        self.dishes.append(dish)  
   
 # 下架菜品 
    def remove_dish(self, name):  
        for dish in self.dishes:  
            if dish["name"] == name:  
                self.dishes.remove(dish)  
                return True  
        return False  
# 修改菜品    
    def modify_dish(self, name, price):  
        for dish in self.dishes:  
            if dish["name"] == name:  
                dish["price"] = price  
                return True  
        return False  
# 2》、每个菜品，都有对应的库存，所有菜品的库存均为999，每出一道菜，库存-1       
    def order_dish(self, name):  
        for dish in self.dishes:  
            if dish["name"] == name:  
                if dish["stock"] > 0:  
                    dish["stock"] -= 1  
                    return True  
                else:  
                    return False  
#收集指定菜品的评分      
    def collect_score(self, name, score):  
        if name in self.scores:  
            self.scores[name].append(score)  
        else:  
            self.scores[name] = [score]  
#指定菜品的平均分   
    def calculate_average_score(self, name):  
        if name in self.scores:  
            return sum(self.scores[name]) / len(self.scores[name])  
        else:  
            return 0  
# 4》、有菜品评分提报功能，对平均分数（菜品总分/打分人数）低于3分的菜品进行强制下架；      
    def remove_below_average_score(self):  
        for dish in self.dishes:  
            score = self.calculate_average_score(dish["name"])  
            if score < 3:  
                self.remove_dish(dish["name"])  
restaurant = Restaurant()
restaurant.add_dish("牛肉饺子", 15)
print(restaurant.dishes)
restaurant.remove_dish("羊汤")
print(restaurant.dishes)
restaurant.modify_dish("牛肉饺子", 5)
print(restaurant.dishes)
restaurant.collect_score("牛肉饺子", 4)
print(restaurant.scores)
restaurant.order_dish("牛肉饺子")
print(restaurant.dishes) 

"""
# 七、定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，
# # 包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，
# # 并调用showInfo方法，输出每个桌子的信息。

"""
class Desk:
    def __init__(self, length, width, hight):
        self.length = length
        self.width = width
        self.hight = hight
    def showInfo(self):
        return f"桌子是 {self.length} 长, {self.width} 宽 ,{self.height} 高"
desk1 = Desk(10, 20, 30)
desk2 = Desk(15, 25, 40)
print(desk1.showInfo())
print(desk2.showInfo())
"""

# 八、定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。
"""class User:
    def __init__(self,username,password):
        self.username = username
        self.password = password

new_user=User("hui","Aa123456")
print("Username:", new_user.username)
print("Password:", new_user.password)
"""
# 九、定义一个计算器类，有加减乘除四个方法
"""
class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            print("不能除以0")
        return a or b

calculator = Calculator()
print(calculator.add(3, 3))#6
print(calculator.subtract(3, 3))#0
print(calculator.multiply(3, 3))#9
print(calculator.divide(3, 3))#1
"""
# 十、创建一个名为Person的类，具有以下属性和方法：
# 属性：name（姓名），age（年龄）
# 方法：greet()，打印出一句问候语，包括该人的姓名和年龄
"""
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} , I am {self.age} years old.")

    def course(self):
        self.greet()

person = Person("hui", 8)
person.course()
"""
# 十一、定义一个图书管理系统类，图书可以新增、修改、删除，要求新增的每个图书都加到txt文本里，数据持久化
# 新增：图书名、作者名称、新建年月日
# 修改：图书名、作者名称、新建年月日
# 删除：图书删掉，且不在展示
# 查看：全量查询，精确查询，需要用户传入形参来控制返回结果
"""
class BookManager:
    def __init__(self, file_path):
        self.file_path = file_path
        self.books = []
            with open(file_path, 'rb') as f:
                self.books = pickle.load(f)
                
    def add_book(self, book_name, author_name, publish_date):
        book = {"book_name": book_name, "author_name": author_name, "publish_date": publish_date}
        self.books.append(book)
        self._save_books()
        
    def update_book(self, book_name, author_name=None, publish_date=None):
        for book in self.books:
            if book["book_name"] == book_name:
                if author_name is not None:
                    book["author_name"] = author_name
                if publish_date is not None:
                    book["publish_date"] = publish_date
                self._save_books()
                return True
        return False
        
    def delete_book(self, book_name):
        for book in self.books:
            if book["book_name"] == book_name:
                self.books.remove(book)
                self._save_books()
                return True
        return False
        
    def search_books(self, query):
        results = []
        for book in self.books:
            if query in book["book_name"] or query in book["author_name"]:
                results.append(book)
        return results
    def _save_books(self):
        with open(self.file_path, 'wb') as f:
            pickle.dump(self.books, f)

# 十二、创建一个名为"Car"的类，该类具有"品牌"和"颜色"属性。
# 创建一个"start_engine"方法，该方法打印出"启动汽车引擎！"的消息。
# 创建一个"stop_engine"方法，该方法打印出"关闭汽车引擎！"的消息
"""

"""
class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def start_engine(self):
        print("启动汽车引擎！")

    def stop_engine(self):
        print("关闭汽车引擎！")


my_car = Car("Toyota", "Red")
my_car.start_engine()
my_car.stop_engine()
"""


# 十三、淘宝商家后台，可以上架商品、下架商品，功能如下：
#  （1） 可以添加商品，商家添加完的商品会存到商品列表
#  1.1  商品要有名称、sku、价格
#  （2） 可以修改商品信息：名称、sku、价格
#  （3） 可以对商品进行下架，下架后的商品不再展示
"""class TaobaoStore:
    def __init__(self):
        self.product_list = []

    def add_product(self, name, sku, price):
        id = 0

        product = {'id': id, 'name': name, 'sku': sku, 'price': price, 'status': '上架'}
        self.product_list.append(product)
        print(f'商品 {name} 添加成功！')

    def modify_product(self, sku, new_name=None, new_price=None):
        for product in self.product_list:
            if product['sku'] == sku:
                if new_name:
                    product['name'] = new_name
                if new_price:
                    product['price'] = new_price
                    print(f'商品 {sku} 信息修改成功！')
                    return
            print(f'找不到SKU为 {sku} 的商品！')

    def take_off_product(self, sku):
        for product in self.product_list:
            if product['sku'] == sku:
                product['status'] = '下架'
                print(f'商品 {sku} 已下架！')
                return
            print(f'找不到SKU为 {sku} 的商品！')

    def display_products(self):
        print("商品列表:")
        for product in self.product_list:
            print(f"名称: {product['name']}, SKU: {product['sku']}, 价格: {product['price']}, 状态: {product['status']}")


taobao_store = TaobaoStore()

taobao_store.add_product('手机', 'SKU001', 1999.99)
taobao_store.add_product('电脑', 'SKU002', 4999.99)
taobao_store.add_product('耳机', 'SKU003', 199.99)

taobao_store.display_products()

taobao_store.modify_product('SKU001', new_name='新手机', new_price=2299.99)
taobao_store.take_off_product('SKU002')

taobao_store.display_products()
"""
# 十四、定义一个人类
# 1.小明和小美都爱跑步
# 2.小美体重45.0公斤
# 3.小明体重75.0公斤
# 4.每次跑步都会减少0.5公斤
# 5.每次吃东西都会增加1公斤
"""class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight
        self.running_weight = weight  # 初始跑步体重与初始体重相同
        self.eating_weight = weight  # 初始吃体重与初始体重相同
    def run(self):

        self.weight -= 0.5
        print(f"{self.name}跑了步，现在体重是{self.weight}公斤。")
    def eat(self):

        self.weight += 1
        print(f"{self.name}吃了东西，现在体重是{self.weight}公斤。")
    def get_weight_difference(self):

        return self.weight - self.initial_weight
    def __str__(self):
        return f"{self.name}的当前体重是{self.weight}公斤。"

xiaoming = Person("小明", 75.0)
xiaomei = Person("小美", 45.0)
xiaoming.run()  # 小明跑了步，现在体重是74.5公斤。
xiaoming.eat()  # 小明吃了东西，现在体重是75.5公斤。
print(xiaoming)  # 小明的当前体重是75.5公斤。
print(xiaomei)  # 小美的当前体重是45公斤。
"""

# 十五、士兵瑞恩有一把ak47
# 士兵可以开火（开火扣动的是扳机）
# 枪能够发射子弹（把子弹打出去）
# 抢能够装子弹–增加子弹数量
# 要求没子弹，需要输出没有子弹了，且发射失败

"""class Soldier:
    def __init__(self, name, gun):
        self.name = name
        self.gun = gun
        self.ammo = 0  # 初始没有子弹
    def fire(self):
        if self.ammo > 0:
            print(f"{self.name}开火了！")
            self.gun.fire()  # 扣动扳机开火
            self.ammo -= 1  # 发射一颗子弹，剩余子弹数量减1
        else:
            print(f"{self.name}没有子弹了，无法开火！")
class Gun:
    def __init__(self, name):
        self.name = name
    def fire(self):
        print(f"{self.name}发射了一颗子弹！")
class Ammunition:
    def __init__(self, gun):
        self.gun = gun
        self.quantity = 0  # 初始没有子弹
    def load(self, quantity):
        self.quantity += quantity  # 增加子弹数量
        print(f"{self.gun.name}装载了{quantity}颗子弹！")
    def unload(self):
        if self.quantity > 0:
            self.quantity -= 1  # 减少一颗子弹数量，如果数量不足则无法卸载子弹
            print(f"{self.gun.name}卸载了一颗子弹！")
        else:
            print(f"{self.gun.name}没有子弹了，无法卸载！")
soldier = Soldier("John", Gun("AK47"))
ammunition = Ammunition(soldier.gun)
ammunition.load(10)
soldier.fire()
ammunition()
"""